package com.sub.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 时间处理类
 */
public class DateUtil {

    public static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static final SimpleDateFormat datetimeFormats = new SimpleDateFormat("yyyyMMddHHmmss");
    public static final SimpleDateFormat datetimeFormatss = new SimpleDateFormat("yyyyMMddHHmmssSSS");
    public static final SimpleDateFormat dateFormatm = new SimpleDateFormat("yyyy-MM");
    public static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    public static final SimpleDateFormat dateFormats = new SimpleDateFormat("yyyyMMdd");
    public static final SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
    public static final SimpleDateFormat timeFormats = new SimpleDateFormat("HHmmss");
    public static final SimpleDateFormat timeFormat2 = new SimpleDateFormat("HH:mm");
    public static final SimpleDateFormat timeFormat2s = new SimpleDateFormat("HHmm");
    public static final SimpleDateFormat dateFormatToChinese = new SimpleDateFormat("yyyy年MM月dd日");

    /**
     * @description：获得当前时间
     * @return:java.util.Date
     */
    public static Date now() {
        return new Date();
    }

    /**
     * @param year 年
     * @return boolean
     * @description 是否闰年
     */
    public static boolean isLeapYear(int year) {
        return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    }

    /**
     * @description：获得当前日期时间
     * @format：日期时间格式 yyyy-MM-dd HH:mm:ss
     * @return：String
     */
    public static String currentDatetime() {
        return datetimeFormat.format(now());
    }

    /**
     * @description：获得当前日期时间
     * @format：日期时间格式 yyyyMMddHHmmss
     * @return：String
     */
    public static String currentDatetimes() {
        return datetimeFormats.format(now());
    }

    /**
     * @description：获得当前日期时间
     * @format：日期时间格式 yyyyMMddHHmmssSSS
     * @return：String
     */
    public static String currentDatetimess() {
        return datetimeFormatss.format(now());
    }

    /**
     * @description：获得当前日期
     * @format：日期格式yyyy-MM-dd
     * @return：String
     */
    public static String currentDate() {
        return dateFormat.format(now());
    }

    /**
     * @description：获得当前日期
     * @format：日期格式yyyyMMdd
     * @return：String
     */
    public static String currentDates() {
        return dateFormats.format(now());
    }

    /**
     * @description：获得当前时间
     * @format：时间格式HH:mm:ss
     * @return:String
     */
    public static String currentTime() {
        return timeFormat.format(now());
    }

    /**
     * @description：获得当前时间
     * @format：时间格式HHmmss
     * @return:String
     */
    public static String currentTimes() {
        return timeFormats.format(now());
    }

    /**
     * @description：格式化日期时间
     * @format：日期时间格式yyyy-MM-dd HH:mm:ss
     * @return:String
     */
    public static String formatDatetime(Date date) {
        return datetimeFormat.format(date);
    }

    /**
     * @description： 格式化日期
     * @format：日期格式yyyy-MM-dd
     * @return:String
     */
    public static String formatDate(Date date) {
        return dateFormat.format(date);
    }

    /**
     * @description：格式化时间
     * @format：时间格式HH:mm:ss
     * @return:String
     */
    public static String formatTime(Date date) {
        return timeFormat.format(date);
    }

    /**
     * @param date
     * @param pattern 格式化模式，详见{@link SimpleDateFormat}构造器
     *                <code>SimpleDateFormat(String pattern)</code>
     * @return String
     * @description：格式化日期时间
     */
    public static String formatDatetime(Date date, String pattern) {
        SimpleDateFormat customFormat = (SimpleDateFormat) datetimeFormat.clone();
        customFormat.applyPattern(pattern);
        return customFormat.format(date);
    }

    /**
     * @param datetime
     * @return java.utils.Date
     * @description 将字符串日期时间转换成java.utils.Date类型
     * @format 日期时间格式yyyy-MM-dd HH:mm:ss
     */
    public static Date parseDatetime(String datetime) throws ParseException {
        return datetimeFormat.parse(datetime);
    }

    /**
     * @param date
     * @return java.utils.Date
     * @throws ParseException
     * @description 将字符串日期时间转换成java.utils.Date类型
     * @format 日期时间格式yyyy-MM-dd
     */
    public static Date parseDate(String date) throws ParseException {
        return dateFormat.parse(date);
    }

    /**
     * @param time
     * @return java.utils.Date
     * @throws ParseException
     * @description 将字符串日期转换成java.utils.Date类型
     * @format 时间格式 HH:mm:ss
     */
    public static Date parseTime(String time) throws ParseException {
        return timeFormat.parse(time);
    }

    /**
     * @param datetime
     * @param pattern
     * @return java.utils.Date
     * @throws ParseException
     * @description 根据自定义pattern将字符串日期转换成java.utils.Date类型
     */
    public static Date parseDatetime(String datetime, String pattern) throws ParseException {
        SimpleDateFormat format = (SimpleDateFormat) datetimeFormat.clone();
        format.applyPattern(pattern);
        return format.parse(datetime);
    }

    /**
     * @param currDate 要格式化的日期
     * @param format   日期格式，如yyyy-MM-dd
     * @return String 返回格式化后的日期，格式由参数<code>format</code>
     * 定义，如yyyy-MM-dd，如2013-03-29
     * @description 根据格式得到格式化后的日期
     * @see SimpleDateFormat#format(Date)
     */
    public static String getFormatDate(Date currDate, String format) {
        if (currDate == null) {
            return "";
        }
        SimpleDateFormat dtFormatdB = null;
        try {
            dtFormatdB = new SimpleDateFormat(format);
            return dtFormatdB.format(currDate);
        } catch (Exception e) {
            dtFormatdB = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            try {
                return dtFormatdB.format(currDate);
            } catch (Exception ex) {
            }
        }
        return null;
    }

    /**
     * @param date
     * @return String
     * @description 把20130808 格式化为 2013-08-08 或者 20130808080808 格式化为 2013-08-08
     * 08：08：08
     */
    public static String rmalizeDateTime(String date) {
        try {
            if (date != null) {
                if (date.length() == 8) {
                    date = dateFormat.format(dateFormats.parse(date)).toString();
                } else if (date.length() == 14) {
                    date = datetimeFormat.format(datetimeFormats.parse(date)).toString();
                } else if (date.length() == 4) {
                    date = timeFormat2.format(timeFormat2s.parse(date)).toString();
                }
                return date;
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * @param date
     * @return String
     * @description 把2013-08-08 格式化为 20130808 或者 2013-08-08 08:08:08 格式化为
     * 20130808080808
     */
    public static String normalizeDateTime(String date) {
        try {
            if (date != null) {
                if (date.contains(":")) {
                    if (date.length() == 5) {
                        date = timeFormat2s.format(timeFormat2.parse(date));
                    } else {
                        date = datetimeFormats.format(datetimeFormat.parse(date));
                    }
                } else {
                    date = dateFormats.format(dateFormat.parse(date));
                }
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * @param date
     * @return String
     * @description 把20130808 格式化为 2013-08-08
     */
    public static String unNormalizeDateTime(String date) {
        try {
            SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
            formatter.setLenient(false);
            Date newDate = formatter.parse(date);
            formatter = new SimpleDateFormat("yyyy-MM-dd");
            return formatter.format(newDate);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @return java.utils.Calendar
     * @description 获得当前日历
     */
    public static Calendar calendar() {
        Calendar cal = GregorianCalendar.getInstance(Locale.CHINESE);
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        return cal;
    }

    /**
     * @return long
     * @description 获得当前时间的毫秒数
     */
    public static long millis() {
        return System.currentTimeMillis();
    }

    /**
     * @return java.utils.Date
     * @description 获得当前时间的前一天时间
     */
    public static Date getPrevDay() {
        Date dNow = new Date(); // 当前时间
        Date dBefore;
        Calendar calendar = Calendar.getInstance(); // 得到日历
        calendar.setTime(dNow);// 把当前时间赋给日历
        calendar.add(Calendar.DAY_OF_MONTH, -1); // 设置为前一天
        dBefore = calendar.getTime(); // 得到前一天的时间
        return dBefore;
    }

    /**
     * @return java.utils.Date
     * @description 获得传入时间的前一天时间
     */
    public static Date getPrevDay(Date date, int day) {
        Date dBefore;
        Calendar calendar = Calendar.getInstance(); // 得到日历
        calendar.setTime(date);// 把当前时间赋给日历
        calendar.add(Calendar.DAY_OF_MONTH, -day); // 设置为前一天
        dBefore = calendar.getTime(); // 得到前一天的时间
        return dBefore;
    }

    /**
     * @param days 天数间隔
     * @return java.utils.Date
     * @description 获得当前时间的后 N 天时间
     */
    public static Date getNextDay(int days) {
        Date dNow = new Date(); // 当前时间
        Date dNext = new Date();
        Calendar calendar = Calendar.getInstance(); // 得到日历
        calendar.setTime(dNow);// 把当前时间赋给日历
        calendar.add(Calendar.DAY_OF_MONTH, days); // 设置为前一天
        dNext = calendar.getTime(); // 得到前一天的时间
        return dNext;
    }

    /**
     * @param days 天数间隔
     * @return java.utils.Date
     * @description 获得当前时间的后 N 天时间
     */
    public static Date getNextDay(Date date, int days) {
        Date dNext = new Date();
        Calendar calendar = Calendar.getInstance(); // 得到日历
        calendar.setTime(date);// 把当前时间赋给日历
        calendar.add(Calendar.DAY_OF_MONTH, days); // 设置为前一天
        dNext = calendar.getTime(); // 得到前一天的时间
        return dNext;
    }

    /**
     * 当前时间递增分钟
     *
     * @param minute
     * @return
     * @Title: getNextMinute. <br/>
     * @Description: TODO(这里用一句话描述这个方法的作用).<br />
     * @Date: 2018年2月3日 下午4:17:40 <br/>
     * @since JDK 1.8
     */
    public static Date getNextMinute(int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(now());
        calendar.add(Calendar.MINUTE, minute);
        return calendar.getTime();
    }

    /**
     * 传入时间递增分钟
     *
     * @param date
     * @param minute
     * @return
     * @Title: getNextMinute. <br/>
     * @Description: TODO(这里用一句话描述这个方法的作用).<br />
     * @Date: 2018年2月3日 下午4:17:40 <br/>
     * @since JDK 1.8
     */
    public static Date getNextMinute(Date date, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minute);
        return calendar.getTime();
    }

    /**
     * 传入时间递增秒钟
     *
     * @param date
     * @param second
     * @return
     * @since JDK 1.8
     */
    public static Date getNextSecond(Date date, int second) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.SECOND, second);
        return calendar.getTime();
    }

    /**
     * @return int
     * @description 获取当前年份
     */
    public static int currentYear() {
        Calendar cal = Calendar.getInstance();
        return cal.get(Calendar.YEAR);
    }

    /**
     * 获取当前月份
     *
     * @return int
     */
    public static int currentMonth() {
        Calendar cal = Calendar.getInstance();
        return cal.get(Calendar.MONTH) + 1;
    }

    /**
     * @return int
     * @description 获得当前Chinese月份
     */
    public static int month() {
        return calendar().get(Calendar.MONTH) + 1;
    }

    /**
     * @return int
     * @description 获得月份中的第几天
     */
    public static int dayOfMonth() {
        return calendar().get(Calendar.DAY_OF_MONTH);
    }

    /**
     * @return int
     * @description 获取今天是星期的第几天
     */
    public static int dayOfWeek() {
        return calendar().get(Calendar.DAY_OF_WEEK);
    }

    /**
     * @return int
     * @description 获取今天是年中的第几天
     */
    public static int dayOfYear() {
        return calendar().get(Calendar.DAY_OF_YEAR);
    }

    /**
     * @param src 原时间
     * @param dst 目标时间
     * @return boolean ture符合 false不符合
     * @description 判断原日期是否在目标日期之前
     */
    public static boolean isBefore(Date src, Date dst) {
        return src.before(dst);
    }

    /**
     * @param src 原时间
     * @param dst 目标时间
     * @return boolean ture符合 false不符合
     * @description 判断原日期是否在目标日期之后
     */
    public static boolean isAfter(Date src, Date dst) {
        return src.after(dst);
    }

    /**
     * @param date1
     * @param date2
     * @return boolean ture符合 false不符合
     * @description 判断两日期是否相同
     */
    public static boolean isEqual(Date date1, Date date2) {
        return date1.compareTo(date2) == 0;
    }

    /**
     * @param beginDate 日期范围开始
     * @param endDate   日期范围结束
     * @param src       需要判断的日期
     * @return boolean ture符合 false不符合
     * @description 判断某个日期是否在某个日期范围
     */
    public static boolean between(Date beginDate, Date endDate, Date src) {
        return beginDate.before(src) && endDate.after(src);
    }

    /**
     * 获取两个日期之间的实际天数，支持跨年
     */
    public static Integer getDaysBetween(Calendar start, Calendar end) {
        if (start.after(end)) {
            Calendar swap = start;
            start = end;
            end = swap;
        }
        int days = end.get(Calendar.DAY_OF_YEAR) - start.get(Calendar.DAY_OF_YEAR);
        int y2 = end.get(Calendar.YEAR);
        if (start.get(Calendar.YEAR) != y2) {
            start = (Calendar) start.clone();
            do {
                days += start.getActualMaximum(Calendar.DAY_OF_YEAR);
                start.add(Calendar.YEAR, 1);
            } while (start.get(Calendar.YEAR) != y2);
        }
        return days;
    }

    /**
     * 获取两个日期之间的实际天数，支持跨年
     */
    public static Integer getDaysBetween(Date start, Date end) {
        Integer days = null;
        Calendar _start = Calendar.getInstance();
        _start.setTime(start);
        Calendar _end = Calendar.getInstance();
        _end.setTime(end);
        days = getDaysBetween(_start, _end);
        return days;
    }

    /**
     * 获取两个日期之间的实际天数，支持跨年
     */
    public static Integer getDaysBetween(String start, String end) {
        Integer days = null;
        try {
            Date _start = parseDate(start);
            Date _end = parseDate(end);
            days = getDaysBetween(_start, _end);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return days;
    }

    /**
     * @return java.utils.Date
     * @description 获得当前月的第一天
     */
    public static Date firstDayOfMonth() {
        Calendar cal = calendar();
        cal.set(Calendar.DAY_OF_MONTH, 1); // M月置1
        cal.set(Calendar.HOUR_OF_DAY, 0);// H置零
        cal.set(Calendar.MINUTE, 0);// m置零
        cal.set(Calendar.SECOND, 0);// s置零
        cal.set(Calendar.MILLISECOND, 0);// S置零
        return cal.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得当前月的最后一天
     */
    public static Date lastDayOfMonth() {
        Calendar ca = Calendar.getInstance();
        ca.add(Calendar.MONTH, 1); // 加一个月
        ca.set(Calendar.DAY_OF_MONTH, 1); // 把日期设置为当月第一天
        ca.set(Calendar.HOUR_OF_DAY, 0);// H置零
        ca.set(Calendar.MINUTE, 0);// m置零
        ca.set(Calendar.SECOND, 0);// s置零
        ca.set(Calendar.MILLISECOND, 0);// S置零
        ca.set(Calendar.MILLISECOND, -1);// 毫秒-1
        return ca.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得下个月的第一天
     */
    public static Date firstDayOfNextMonth() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, 1);// 加一个月
        cal.set(Calendar.DATE, 1);// 把日期设置为当月第一天
        cal.set(Calendar.HOUR_OF_DAY, 0);// H置零
        cal.set(Calendar.MINUTE, 0);// m置零
        cal.set(Calendar.SECOND, 0);// s置零
        cal.set(Calendar.MILLISECOND, 0);// S置零
        return cal.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得下个月的最后一天
     */
    public static Date lastDayOfNextMonth() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, 2); // 加一个月
        cal.set(Calendar.DAY_OF_MONTH, 1); // 把日期设置为当月第一天
        cal.set(Calendar.HOUR_OF_DAY, 0);// H置零
        cal.set(Calendar.MINUTE, 0);// m置零
        cal.set(Calendar.SECOND, 0);// s置零
        cal.set(Calendar.MILLISECOND, 0);// S置零
        cal.set(Calendar.MILLISECOND, -1);// 毫秒-1
        return cal.getTime();
    }

    /**
     * 获取某年某月第一天
     *
     * @param date
     * @return Date
     * @Throws
     * @Author: chetao
     * @Date: 2019年1月22日 上午10:53:33
     */
    public static Date firstDayOfMonth(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        return cal.getTime();
    }

    /**
     * @param year
     * @param month 注意月份是从0开始的，5 则为六月份
     * @return java.utils.Date
     * @description 获取某年某月最后一天
     */
    public static Date lastDayOfMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, year);
        cal.set(Calendar.MONTH, month);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DATE));
        return cal.getTime();
    }

    /**
     * 获取某年某月最后一天
     *
     * @param date
     * @return Date 传入日期
     * @Throws
     * @Author: chetao
     * @Date: 2019年1月22日 上午10:53:12
     */
    public static Date lastDayOfMonth(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DATE));
        return cal.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得下一个月的当天
     */
    public static Date toDayOfNextMonth(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MONTH, 1);// 加一月
        return cal.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得下N个月的当天
     */
    public static Date toDayOfNextMonth(Date date, int month) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MONTH, month);// 加一月
        return cal.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得下一年的当天
     */
    public static Date toDayOfNextYear(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.YEAR, 1);// 加一年
        return cal.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得某年的二月份的最后一天
     */
    public static Date februaryOfCurrentYear(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.set(Calendar.MONTH, 1); // 设置为二月
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DATE));
        return cal.getTime();
    }

    /**
     * @param week format: Calendar.FRIDAY
     * @return java.utils.Date
     * @description 获取某个星期几的日期
     */
    public static Date weekDay(int week) {
        Calendar cal = calendar();
        cal.set(Calendar.DAY_OF_WEEK, week);
        return cal.getTime();
    }

    /**
     * @return java.utils.Date
     * @description 获得周五日期
     * <p>
     * 注：日历工厂方法{@link #calendar()}
     * 设置类每个星期的第一天为Monday，US等每星期第一天为sunday
     */
    public static Date friday() {
        return weekDay(Calendar.FRIDAY);
    }

    /**
     * @return java.utils.Date
     * @description 获得周六日期
     * <p>
     * 注：日历工厂方法{@link #calendar()}
     * 设置类每个星期的第一天为Monday，US等每星期第一天为sunday
     */
    public static Date saturday() {
        return weekDay(Calendar.SATURDAY);
    }

    /**
     * @return java.utils.Date
     * @description 获得周日日期
     * <p>
     * 注：日历工厂方法{@link #calendar()}
     * 设置类每个星期的第一天为Monday，US等每星期第一天为sunday
     */
    public static Date sunday() {
        return weekDay(Calendar.SUNDAY);
    }

    /**
     * 计算两个时间相差（天、小时、分钟、秒）
     *
     * @param startTime
     * @param endTime
     * @param type      d-天,h-小时,m-分钟,s-秒
     * @return
     */
    public static Long dateDiff(Date startTime, Date endTime, String type) {
        long source = 0;
        long nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
        long nh = 1000 * 60 * 60;// 一小时的毫秒数
        long nm = 1000 * 60;// 一分钟的毫秒数
        long ns = 1000;// 一秒钟的毫秒数
        long diff;
        long day = 0;
        long hour = 0;
        long min = 0;
        long sec = 0;
        // 获得两个时间的毫秒时间差异
        diff = endTime.getTime() - startTime.getTime();
        day = diff / nd;// 计算差多少天
        hour = diff % nd / nh + day * 24;// 计算差多少小时
        min = diff % nd % nh / nm + day * 24 * 60;// 计算差多少分钟
        sec = diff % nd % nh % nm / ns;// 计算差多少秒

        if (type.equalsIgnoreCase("d")) {
            source = day;
        } else if (type.equalsIgnoreCase("h")) {
            source = hour;
        } else if (type.equalsIgnoreCase("m")) {
            source = min;
        } else if (type.equalsIgnoreCase("s")) {
            source = sec;
        }
        return source;
    }

    /**
     * 计算两个时间相差秒
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public static Long dateSeconds(Date startTime, Date endTime) {
        long m = dateDiff(startTime, endTime, "m");
        long s = dateDiff(startTime, endTime, "s");
        return (m * 60) + s;
    }

    /**
     * 计算两个时间相差秒
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public static Long dateSeconds(String startTime, String endTime) {
        long m = dateDiff(startTime, endTime, "m");
        long s = dateDiff(startTime, endTime, "s");
        return (m * 60) + s;
    }

    /**
     * 计算两个时间相差（天、小时、分钟、秒）
     *
     * @param startTime
     * @param endTime
     * @param type      d-天,h-小时,m-分钟,s-秒
     * @return
     */
    public static Long dateDiff(String startTime, String endTime, String type) {
        long source = 0;
        long nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
        long nh = 1000 * 60 * 60;// 一小时的毫秒数
        long nm = 1000 * 60;// 一分钟的毫秒数
        long ns = 1000;// 一秒钟的毫秒数
        long diff;
        long day = 0;
        long hour = 0;
        long min = 0;
        long sec = 0;
        // 获得两个时间的毫秒时间差异
        try {
            diff = datetimeFormat.parse(endTime).getTime() - datetimeFormat.parse(startTime).getTime();
            day = diff / nd;// 计算差多少天
            hour = diff % nd / nh + day * 24;// 计算差多少小时
            min = diff % nd % nh / nm + day * 24 * 60;// 计算差多少分钟
            sec = diff % nd % nh % nm / ns;// 计算差多少秒
            // 输出结果
            // System.out.println("时间相差：" + day + "天" + (hour - day * 24) + "小时"
            // + (min - day * 24 * 60) + "分钟" + sec + "秒。");
            // System.out.println("hour=" + hour + ",min=" + min);
            // if (str.equalsIgnoreCase("h")) {
            // return hour;
            // } else {
            // return min;
            // }

        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        if (type.equalsIgnoreCase("d")) {
            source = day;
        } else if (type.equalsIgnoreCase("h")) {
            source = hour;
        } else if (type.equalsIgnoreCase("m")) {
            source = min;
        } else if (type.equalsIgnoreCase("s")) {
            source = sec;
        }
        return source;
    }

    /**
     * @param number N个月数
     * @return String
     * @description 得到本日的前几个月时间 如果number=2 当日为2013-03-1 15:30:00, 那么获得2013-01-1
     * 15:30:00
     */
    public static String getDateBeforeMonth(int number) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, -number);
        return getFormatDate(cal.getTime(), "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * @param number N个月数
     * @return String
     * @description 得到本日的后几个月时间 如果number=2 当日为2013-03-1 15:30:00, 那么获得2013-05-1
     * 15:30:00
     */
    public static String getDateNextMonth(int number) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, number);
        return getFormatDate(cal.getTime(), "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * @param number N个月数
     * @return String
     * @description 得到本日的前几个月时间 如果number=2 当日为20130301153000, 那么获得20130101153000
     */
    public static String getDateBeforeMonths(int number) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, -number);
        return getFormatDate(cal.getTime(), "yyyyMMddHHmmss");
    }

    /**
     * @param number N个月数
     * @return String
     * @description 得到本日的后几个月时间 如果number=2 当日为20130301153000, 那么获得20130501153000
     */
    public static String getDateNextMonths(int number) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, number);
        return getFormatDate(cal.getTime(), "yyyyMMddHHmmss");
    }

    /**
     * @param number N个月数
     * @return String
     * @description 得到本日的后几个月时间
     */
    public static Date getDateNextMont(int number) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, number);
        return cal.getTime();
    }

    /**
     * @param dateStr 日期字符串 ,格式yyyyMMddHHmmss
     * @param m       ,分钟数,m>0表示m分钟之后的时间，m<0表示m分钟之前的时间
     * @return String
     * @description 日期数相加(除月份) 返回 月份相加的结果
     */
    public static String DateOperation(String dateStr, int m) {
        try {
            Date mydate = datetimeFormats.parse(dateStr);
            Calendar cal = Calendar.getInstance();
            cal.setTime(mydate);
            cal.add(Calendar.MINUTE, m); // 加分钟数
            return datetimeFormats.format(cal.getTime());
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * @param yyyyMM 如 2013/10
     * @return
     * @description 返回当前月份的所有周一到周五的日期
     */
    public static List<String> WorkDate(String yyyyMM) {
        List<String> workdates = new ArrayList<String>();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        sdf1.setLenient(false);
        SimpleDateFormat sdf2 = new SimpleDateFormat("EEE");
        for (int i = 1; i < 32; i++) {
            try {
                Date date = sdf1.parse(yyyyMM + "-" + i);
                if (sdf2.format(date).equals("星期六") || sdf2.format(date).equals("星期日")) {
                    continue;
                } else {
                    workdates.add(sdf1.format(date));
                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return workdates;
    }

    // 0-23小时的下拉框
    public static String Time24Select(int selected) {
        String times = "";
        for (int i = 0; i < 24; i++) {
            if (i == selected) {
                times += "<option value=" + i + " selected>" + i + "</option>";
            } else {
                times += "<option value=" + i + ">" + i + "</option>";
            }
        }
        return times;
    }

    /**
     * @return
     * @throws ParseException
     * @description 当前日期减去传入日期
     * @author bbear
     * @since JDK 1.7
     */
    public static Long currentSubtract(Date date) {
        Date currentDate = new Date();
        return dateDiff(currentDate, date, "d");
    }

    /**
     * @return String
     * @description 获取当前天数小于10的时候前面补0
     * @author bbear
     * @since JDK 1.7
     */
    public static String currentDay() {
        return String.format("%02d", dayOfMonth());
    }

    /**
     * @return String
     * @description 获取当前月份小于10的时候前面补0
     * @author bbear
     * @since JDK 1.7
     */
    public static String currentMonthWithZero() {
        return String.format("%02d", month());
    }

    /**
     * 判断是否是周末
     *
     * @param date
     * @return
     * @throws ParseException
     */
    public static boolean isWeekend(Date date) throws ParseException {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int day = cal.get(Calendar.DAY_OF_WEEK);
        if (day == Calendar.SATURDAY || day == Calendar.SUNDAY) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断是否是周六
     *
     * @param date
     * @return
     * @throws ParseException
     */
    public static boolean isWeekend_SATURDAY(Date date) throws ParseException {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int day = cal.get(Calendar.DAY_OF_WEEK);
        if (day == Calendar.SATURDAY) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断是否是周日
     *
     * @param date
     * @return
     * @throws ParseException
     */
    public static boolean isWeekend_SUNDAY(Date date) throws ParseException {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int day = cal.get(Calendar.DAY_OF_WEEK);
        if (day == Calendar.SUNDAY) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * @return boolean
     * @description 当前时间是否是当月最后一天
     * @author bbear
     * @since JDK 1.7
     */
    public static boolean isLastDayOfMonth() {
        return dayOfMonth() == Calendar.getInstance().getActualMaximum(Calendar.DAY_OF_MONTH);
    }

    /**
     * @return boolean
     * @description 当前时间是否是当月第一天
     * @author bbear
     * @since JDK 1.7
     */
    public static boolean isStartDayOfMonth() {
        return dayOfMonth() == Calendar.getInstance().getActualMinimum(Calendar.DAY_OF_MONTH);
    }

    /**
     * @param date
     * @return
     * @description 获取当前日期第一秒 例：input 2016-06-08 12:45:45 out 2016-06-08
     * 00:00:00
     * @author bbear
     * @since JDK 1.7
     */
    public static Date getStartOfDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * @param date
     * @return
     * @description 获取当前日期最后一秒 例：input 2016-06-08 12:45:45 out 2016-06-08
     * 23:59:59
     * @author bbear
     * @since JDK 1.7
     */
    public static Date getEndOfDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * @return
     * @description 获取当前日期第一秒 20160608 00:00:00
     * @author bbear
     * @since JDK 1.7
     */
    public static String getStartOfDays(Date date) {
        return formatDatetime(getStartOfDay(date), "yyyyMMdd HH:mm:ss");
    }

    /**
     * @return
     * @description 获取当前日期最后一秒 20160608 23:59:59
     * @author bbear
     * @since JDK 1.7
     */
    public static String getEndOfDays(Date date) {
        return formatDatetime(getEndOfDay(date), "yyyyMMdd HH:mm:ss");
    }

    /**
     * @description 获得昨天是这个月份中的第几天
     */
    public static String yesterdayOfMonth() {
        return String.format("%02d", calendar().get(Calendar.DAY_OF_MONTH) - 1);
    }

    /**
     * @param date
     * @return
     * @description 获取传入日期的明年的前一天
     * @author bbear
     * @since JDK 1.7
     */
    public static Date nextYearYesterday(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.YEAR, 1);
        cal.add(Calendar.DAY_OF_MONTH, -1);
        return cal.getTime();
    }

    /**
     * 验证时间格式是否正确
     *
     * @param strDate
     * @param dateFormat
     * @return
     */
    public static boolean isValidDate(String strDate, String dateFormat) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
            sdf.parse(strDate);
            return true;
        } catch (Exception e) {
            // 如果throw java.text.ParseException或者NullPointerException说明格式不对
            return false;
        }
    }

    public static boolean isAllowDate(String strDate, String dateFormat) {
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        try {
            Date orderDate = sdf.parse(strDate);
            Calendar ordcal = Calendar.getInstance();
            ordcal.setTime(orderDate);

            Calendar culcal = Calendar.getInstance();
            culcal.setTime(sdf.parse(getDateStr()));

            Calendar nextcal = Calendar.getInstance();
            nextcal.setTime(sdf.parse(getDateStr()));
            nextcal.add(Calendar.DATE, 1);

            Calendar lastcal = Calendar.getInstance();
            lastcal.setTime(sdf.parse(getDateStr()));
            lastcal.add(Calendar.DATE, -1);

            if (ordcal.compareTo(lastcal) >= 0 && ordcal.compareTo(nextcal) <= 0) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 获取当前时间的字符串（yyyyMMdd）
     */
    public static String getDateStr() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        return sdf.format(new Date());
    }

    /*
     * @description: 获取时间
     *
     * @param: timeFormat: 预期日期格式：样例： yyyyMMddHHmmss
     *
     * @param: nextTime: 前后时间，单位：秒，获取当前时间传入0即可
     *
     * @return: 返回时间字符串
     */
    public static String getTimeString(SimpleDateFormat timeFormat, int nextTime) {
        Calendar beforeTime = Calendar.getInstance();
        beforeTime.add(Calendar.SECOND, nextTime);
        return timeFormat.format(beforeTime.getTime());
    }

    /*
     * @description: 获取时间
     *
     * @param: nextTime: 前后时间，单位：秒，获取当前时间传入0即可
     *
     * @return: 返回date格式的时间
     */
    public static Date getDateTime(int nextTime) {
        Calendar calendar = calendar();
        calendar.setTime(new Date());
        calendar.add(Calendar.SECOND, nextTime);
        return calendar.getTime();
    }

    /*
     * @description: 转换时间: 格式1 转换到 格式2，可对时间进行调整
     *
     * @param: nextTime: 前后时间，单位：秒，获取当前时间传入0即可
     */
    public static String formatTime(String srcTime, SimpleDateFormat srcTimeFormat, SimpleDateFormat dstTimeFormat,
                                    int nextTime) throws ParseException {
        Calendar calendar = calendar();
        calendar.setTime(srcTimeFormat.parse(srcTime));
        calendar.add(Calendar.SECOND, nextTime);
        return dstTimeFormat.format(calendar.getTime());
    }

    /**
     * @description: date转时间字符串
     * @param: timeFormat：格式,样例：yyyy-MM-dd
     * HH:mm:ss
     */
    public static String date2TimeString(SimpleDateFormat timeFormat, Date date) {
        return timeFormat.format(date);
    }

    /**
     * @description: 时间字符串转date
     * @param: timeFormat：格式,样例：yyyy-MM-dd
     * HH:mm:ss
     */
    public static Date timeString2Date(SimpleDateFormat timeFormat, String dateTime) throws ParseException {
        return timeFormat.parse(dateTime);
    }

    /**
     * 获取两个时间之间的秒数，支持跨年
     */
    public static long getSecondBetweenDate(Date date1, Date date2) {
        return Math.abs(date1.getTime() - date2.getTime()) / 1000;
    }

    /**
     * 获取两个时间之间的实际秒数，支持跨年
     */
    public static long getSecondBetweenDate(SimpleDateFormat date1Format, String date1, SimpleDateFormat date2Format,
                                            String date2) throws ParseException {
        Date date1Date = timeString2Date(date1Format, date1);
        Date date2Date = timeString2Date(date2Format, date2);
        return getSecondBetweenDate(date1Date, date2Date) / 1000;
    }

    /**
     * 获取指定日期是一年的哪一周
     */
    public static long getWeekOfYear(SimpleDateFormat timeFormat, String timeString) throws ParseException {
        Calendar calendar = calendar();
        calendar.setTime(timeFormat.parse(timeString));
        return calendar.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取周的起始日期
     */
    public static String getStartDayByWeek(SimpleDateFormat timeFormat, int year, int weekNo) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        cal.set(Calendar.YEAR, year);
        cal.set(Calendar.WEEK_OF_YEAR, weekNo);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        return timeFormat.format(cal.getTime());
    }

    /**
     * 获取周的截止日期
     */
    public static String getEndDayByWeek(SimpleDateFormat timeFormat, int year, int weekNo) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        cal.set(Calendar.YEAR, year);
        cal.set(Calendar.WEEK_OF_YEAR, weekNo);
        cal.add(Calendar.DAY_OF_WEEK, 6);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        return timeFormat.format(cal.getTime());
    }


}
